package com.ruoyi.mateInventory.service.impl;

import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.mateInventory.domain.MateInventory;
import com.ruoyi.mateInventory.domain.MateInventoryModel;
import com.ruoyi.mateInventory.domain.MateInventoryPlan;
import com.ruoyi.mateInventory.domain.MateInventoryPlanModel;
import com.ruoyi.mateInventory.mapper.MateInventoryMapper;
import com.ruoyi.mateInventory.service.MateInventoryService;
import com.ruoyi.material.domain.MaterialProduct;
import com.ruoyi.mtAudit.domain.MtAudit;
import com.ruoyi.mtAudit.mapper.MtAuditMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;

/**
 * @Author
 * @Version 1.0
 */
@Service
public class MateInventoryServiceImpl implements MateInventoryService {
    @Autowired
    MateInventoryMapper mateInventoryMapper;

    @Autowired
    MtAuditMapper mtAuditMapper;

    @Override
    public List<MaterialProduct> selectProducts(Map<String, Object> resMap) {
        return mateInventoryMapper.selectProducts(resMap);
    }

    @Override
    public int addMateInventory(MateInventory mateInventory) {
        int a = mateInventoryMapper.addMateInventory(mateInventory);
        if (mateInventory.getMateInventoryModels() != null) {
            for (MateInventoryModel mateInventoryModel : mateInventory.getMateInventoryModels()) {
                mateInventoryModel.setDeptId(SecurityUtils.getDeptId());
                mateInventoryModel.setInventoryId(mateInventory.getInventoryId());
                mateInventoryMapper.insertMateInventoryModel(mateInventoryModel);
            }

        }
        return a;
    }

    @Override
    public List<MateInventory> selectMateInventoryList(MateInventory mateInventory) {
        return mateInventoryMapper.selectMateInventoryList(mateInventory);
    }

    @Override
    public MateInventory selectEdit(Long inventoryId) {
        return mateInventoryMapper.selectEdit(inventoryId);
    }

    @Override
    public int updateMateInventory(MateInventory mateInventory) {
        int num = 0;
        MateInventory mateInventory1 = mateInventoryMapper.selectEdit(mateInventory.getInventoryId());
        List<MateInventoryModel> mateInventoryModels = mateInventoryMapper.selectMateInventoryModels(mateInventory.getInventoryId());
        try {
            if (mateInventory.getMateInventoryModels().size() != 0 && mateInventory.getMateInventoryModels() != null) {
                ArrayList<Long> arrayList = new ArrayList<>();
                for (MateInventoryModel mateInventoryModel : mateInventoryModels) {
                    arrayList.add(mateInventoryModel.getInventoryNo());
                }
                ArrayList<Long> mateInventoryModelList = new ArrayList<>();
                for (MateInventoryModel mateInventoryModel : mateInventory.getMateInventoryModels()) {
                    mateInventoryModel.setInventoryId(mateInventory.getInventoryId());
                    Long inventoryNo = mateInventoryModel.getInventoryNo();
                    if (mateInventoryMapper.selectCountNo(inventoryNo) == 1) {
                        mateInventoryModelList.add(inventoryNo);
                        mateInventoryMapper.updateMateInventoryModel(mateInventoryModel);
                    } else {
                        mateInventoryModel.setInventoryId(mateInventory.getInventoryId());
                        mateInventoryMapper.insertMateInventoryModel(mateInventoryModel);

                    }
                }

                TreeSet<Long> longs = new TreeSet<>();
                boolean b = arrayList.removeAll(mateInventoryModelList);
                for (Long aLong : arrayList) {
                    longs.add(aLong);
                }
                if (longs.size() != 0) {
                    for (Long along : longs) {
                        mateInventoryMapper.delteMateInventoryModel(along);
                    }
                }

                num = mateInventoryMapper.updateMateInventory(mateInventory);
            }
        } catch (Exception e) {
            num = mateInventoryMapper.updateMateInventory(mateInventory1);
        }
        return num;
    }

    @Override
    public void removeMateInventory(Long inventoryId) {
        mateInventoryMapper.removeMateInventoryModel(inventoryId);
        mateInventoryMapper.removeMateInventory(inventoryId);
    }

    @Override
    public List<MateInventory> AuditMateInventory(Long deptId) {
        return mateInventoryMapper.AuditMateInventory(deptId);
    }


    @Override
    public int addMateInventoryPlan(MateInventoryPlan mateInventoryPlan) {
        int num = 0;
        Map<String, Object> resMap = new HashMap<>();
        try {
            num = mateInventoryMapper.addMateInventoryPlan(mateInventoryPlan);
            if (mateInventoryPlan.getMateInventoryPlanModels() != null) {
                for (MateInventoryPlanModel mateInventoryPlanModel:mateInventoryPlan.getMateInventoryPlanModels()){
                    mateInventoryPlanModel.setDeptId(SecurityUtils.getDeptId());
                    mateInventoryPlanModel.setInventoryPlanId(mateInventoryPlan.getInventoryPlanId());
                    mateInventoryMapper.insertMateInventoryPlanModel(mateInventoryPlanModel);
                }

                MtAudit mtAudit = new MtAudit();
                mtAudit.setCompanyId(SecurityUtils.getDeptId());
                mtAudit.setOrderId(mateInventoryPlan.getInventoryPlanId());
                mtAudit.setZjName(mateInventoryPlan.getAuditName());
                mtAudit.setOrderType("3");
                mtAudit.setOrderNum(mateInventoryPlan.getInventoryPlanNum());
                mtAudit.setAuditStatus("0");
                mtAudit.setAuditBy(SecurityUtils.getLoginUser().getNickName());
                mtAuditMapper.insertMtAudit(mtAudit);

            }
        } catch (Exception e) {
            num = 0;
            resMap.put("orderId", mateInventoryPlan.getInventoryPlanId());
            resMap.put("orderType", "3");
            mtAuditMapper.deleteMtAuditById(resMap);
            mateInventoryMapper.removeMateInventoryPlan(mateInventoryPlan.getInventoryPlanId());
            mateInventoryMapper.removeMateInventoryPlanModel(mateInventoryPlan.getInventoryPlanId());
        }

        return num;

    }

    @Override
    public List<MateInventoryPlan> MateInventoryPlan(MateInventoryPlan mateInventoryPlan) {
        return mateInventoryMapper.MateInventoryPlan(mateInventoryPlan);
    }

    @Override
    public void removePlan(Long inventoryId) {
        MateInventory mateInventory = new MateInventory();
        mateInventory.setIsPlan("0");
        mateInventory.setInventoryId(inventoryId);
        mateInventoryMapper.updateMateInventory(mateInventory);
        Map<String, Object> resMap = new HashMap<>();
        resMap.put("orderId", mateInventory.getInventoryId());
        resMap.put("orderType", "3");
        mtAuditMapper.deleteMtAuditById(resMap);
    }

    @Override
    public List selectMateInventoryModel(Long deptId) {
        return mateInventoryMapper.selectMateInventoryModel(deptId);
    }

    @Override
    public MateInventoryPlan selectPlan(Long inventoryPlanId) {
        return mateInventoryMapper.selectPlan(inventoryPlanId);
    }


}
